import java.util.Arrays;

/**
 * Created with IntelliJ IDEA
 * Description
 * User:user
 * Date:2021-10-16
 * Time:16:23
 */
public class HomeWork {


    //实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
    public  static  String toString(int[] arry){
        String ret = "[";
        for (int i = 0; i < arry.length; i++) {
            ret += arry[i];
            if(i < arry.length - 1){
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

    public static void main(String[] args) {
        int[] arry = {1,2,3,4};
        System.out.println(toString(arry));
    }

//    //实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
//    public  static int[] copyOf(int[] arry){
//        int[] ret = new int[arry.length];
//        for (int i = 0; i < arry.length; i++) {
//            ret[i] = arry[i];
//        }
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        int[] arry = {9,8,7,5,6};
//        System.out.println(Arrays.toString(copyOf(arry)));
//    }

/*    //给定一个有序整型数组, 实现二分查找
    public static int binarySearch(int[] arry,int key){
        int left = 0;
        int right = arry.length - 1;
        while(left<=right){
            int mid = (left+right)/2;
            if(arry[mid]< key){
                left = mid + 1;
            }else if(arry[mid] == key){
                return mid;
            }else{
                right = mid - 1;
            }
        }
        return -1;

    }

    public static void main(String[] args) {
        int[] arry = {1,5,9,89,99};
        System.out.println(binarySearch(arry,99));
    }*/


            //给定一个整型数组, 判定数组是否有序（递增）
          /*  public static boolean isSort(int[] arry){
                for (int i = 0; i < arry.length - 1; i++) {
                    if(arry[i] > arry[i+1]){
                        return false;
                    }
                }
                return true;
            }

            public static void main(String[] args) {
                int[] arry = {1,4,2,3};
                System.out.println(isSort(arry));
            }
*/

//
//        //冒泡排序
//        public static void bubbleSort(int[] arry){
//            for (int i = 0; i < arry.length -1; i++) {
//                boolean flag = false;
//                for (int j = 0; j < arry.length - 1 - i; j++) {
//                    if(arry[j] > arry[j+1]){
//                        int tmp = arry[j];
//                        arry[j] = arry[j+1];
//                        arry[j+1] = tmp;
//                        flag = true;
//                    }
//                }
//                if(flag == false){
//                    break;
//                }
//            }
//
//        }
//
//        public static void main(String[] args) {
//            int[] arry = {7,9,15,62,4,5,54};
//            bubbleSort(arry);
//            System.out.println(Arrays.toString(arry));
//
//        }

////    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
////    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
////    你可以按任意顺序返回答案。
//    public static int[] answer(int[] arry,int target){
//        int[] ret = new int[2];
//        for (int i = 0; i < arry.length - 1; i++) {
//            for (int j = i + 1; j < arry.length; j++) {
//                if(target == (arry[i] + arry[j])){
//                    ret[0] = i;
//                    ret[1] = j;
//                }
//            }
//        }
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        int[] arry = {2,7,11,15};
//        System.out.println(Arrays.toString(answer(arry,22)));
//    }




/*
    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    public  static  int getNum(int[] arry){
        for (int i = 0; i < arry.length; i++) {
            int count = 0;
            for (int j = 0; j < arry.length; j++) {
                if(arry[i] == arry[j]){
                    count++;
                }
            }
            if(count == 1){
                return count;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arry = {1,5,7,8,7,5,8};
        System.out.println(getNum(arry));
    }
*/

/*
    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。

    public static int num(int[] arry){
        int flag = arry.length / 2;
        for (int i = 0; i < arry.length; i++) {
            int count = 0;
            for (int j = 0; j < arry.length; j++) {
                if(arry[i] == arry[j]){
                    count++;
                }
            }
            if(count > flag){
                return arry[i];
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] arry = {2,2,1,1,1,2,2};
        System.out.println(num(arry));
    }*/

/*  *//*  给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

    输入：arr = [2,6,4,1]

    输出：false

    解释：不存在连续三个元素都是奇数的情况。


    输入：arr = [1,2,34,3,4,5,7,23,12]

    输出：true

    解释：存在连续三个元素都是奇数的情况，即 [5,7,23]*//*
    public static boolean isContinue(int[] arry){
        for (int i = 0; i < arry.length - 2 ; i++) {
            if((arry[i] % 2 != 0) && (arry[i+1] % 2 != 0) && (arry[i+2] % 2 !=0)){
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arry = {1,2,34,3,4,5,7,23,12};
        System.out.println(isContinue(arry));
        int[] arry2 ={2,6,4,1};
        System.out.println(isContinue(arry2));
    }*/

}
